package com.caifu.util;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MathExtend {

	//默认除法运算精度  
	private static final int DEFAULT_DIV_SCALE = 10;
	/** 
	 * 提供精确的加法运算。 
	 * @param v1 
	 * @param v2 
	 * @return 两个参数的和 
	 */  
	public static double add(double v1, double v2)  {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));  
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		BigDecimal result = b1.add(b2);
		return result.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	
	/** 
	 * 提供精确的加法运算 
	 * @param v1   
	 * @param v2 
	 * @return 两个参数数学加和，以字符串格式返回 
	 */  
	public static String add(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);  
		BigDecimal b2 = new BigDecimal(v2);  
		return b1.add(b2).toString(); 
	}
	
	/** 
	 * 提供精确的减法运算。 
	 * @param v1 
	 * @param v2 
	 * @return 两个参数的差 
	 */ 
	public static double subtract(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));  
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		BigDecimal result = b1.subtract(b2);
		return result.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	
	/** 
	 * 提供精确的减法运算。 
	 * @param v1 
	 * @param v2 
	 * @return 两个参数的差 ，以字符串格式返回 
	 */ 
	public static String subtract(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);  
		BigDecimal b2 = new BigDecimal(v2); 
		b1 = b1.stripTrailingZeros();
		b2 = b2.stripTrailingZeros();
		return (b1.subtract(b2)).stripTrailingZeros().toPlainString();
	}
	
	/** 
	 * 提供精确的乘法运算。 
	 * @param v1 
	 * @param v2 
	 * @return 两个参数的积
	 */ 
	public static double multiply(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));  
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		BigDecimal result = b1.multiply(b2);
		return result.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
	}
	
	/** 
	 * 提供精确的乘法运算。 
	 * @param v1 
	 * @param v2 
	 * @return 两个参数的积 ，以字符串格式返回 
	 */ 
	public static String multiply(String v1, String v2) {
		BigDecimal b1 = new BigDecimal(v1);  
		BigDecimal b2 = new BigDecimal(v2); 
		return b1.multiply(b2).toString();
	}
	
	/** 
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 
	 * 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN 
	 * @param v1 
	 * @param v2 
	 * @param scale 表示需要精确到小数点以后几位。 
	 * @return 两个参数的商 
	 */  
	public static double divide(double v1,double v2, int scale) {  
		return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);  
	}  
	
	/** 
	 * 提供（相对）精确的除法运算。
	 * 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。
	 * 舍入模式采用用户指定舍入模式 
	 * @param v1 
	 * @param v2 
	 * @param scale 表示需要精确到小数点以后几位 
	 * @param round_mode 表示用户指定的舍入模式 
	 * @return 两个参数的商 
	 */  
	public static double divide(double v1,double v2,int scale, int round_mode){  
		if(scale < 0) {  
			throw new IllegalArgumentException("The scale must be a positive integer or zero");  
		}  
		BigDecimal b1 = new BigDecimal(Double.toString(v1));  
		BigDecimal b2 = new BigDecimal(Double.toString(v2));  
		return b1.divide(b2, scale, round_mode).doubleValue();  
	}  

	/** 
	 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 
	 * 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN 
	 * @param v1 
	 * @param v2 
	 * @return 两个参数的商，以字符串格式返回 
	 */  
	public static String divide(String v1, String v2) {  
		return divide(v1, v2, DEFAULT_DIV_SCALE);  
	}  

	/** 
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 
	 * 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN 
	 * @param v1 
	 * @param v2 
	 * @param scale 表示需要精确到小数点以后几位 
	 * @return 两个参数的商，以字符串格式返回 
	 */  
	public static String divide(String v1, String v2, int scale) {  
		return divide(v1, v2, DEFAULT_DIV_SCALE, BigDecimal.ROUND_HALF_EVEN);  
	}  
	
	/** 
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 
	 * 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式 
	 * @param v1 
	 * @param v2 
	 * @param scale 表示需要精确到小数点以后几位 
	 * @param round_mode 表示用户指定的舍入模式 
	 * @return 两个参数的商，以字符串格式返回 
	 */  
	public static String divide(String v1, String v2, int scale, int round_mode) {  
		if(scale < 0) {  
			throw new IllegalArgumentException("The scale must be a positive integer or zero");  
		}  
		BigDecimal b1 = new BigDecimal(v1);  
		BigDecimal b2 = new BigDecimal(v2);  
		return b1.divide(b2, scale, round_mode).toString();  
	}  
	
	/** 
	 * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN 
	 * @param v 需要四舍五入的数字 
	 * @param scale 小数点后保留几位 
	 * @return 四舍五入后的结果 
	*/  
	public static double round(double v,int scale){  
		return round(v, scale, BigDecimal.ROUND_HALF_EVEN);  
	} 
	
	/** 
	 * 提供精确的小数位四舍五入处理 
	 * @param v 需要四舍五入的数字 
	 * @param scale 小数点后保留几位 
	 * @param round_mode 指定的舍入模式 
	 * @return 四舍五入后的结果 
	 */  
	public static double round(double v, int scale, int round_mode) {  
		if(scale<0) {  
			throw new IllegalArgumentException("The scale must be a positive integer or zero");  
		}  
		BigDecimal b = new BigDecimal(Double.toString(v));  
		return b.setScale(scale, round_mode).doubleValue();  
	}  
	
	/** 
	 * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN 
	 * @param v 需要四舍五入的数字 
	 * @param scale 小数点后保留几位 
	 * @return 四舍五入后的结果，以字符串格式返回 
	 */  
	public static String round(String v, int scale) {  
		return round(v, scale, BigDecimal.ROUND_HALF_EVEN);  
	}  
	 
	/** 
	 * 提供精确的小数位四舍五入处理 
	 * @param v 需要四舍五入的数字 
	 * @param scale 小数点后保留几位 
	 * @param round_mode 指定的舍入模式 
	 * @return 四舍五入后的结果，以字符串格式返回 
	 */  
	public static String round(String v, int scale, int round_mode) {  
		if(scale<0) {  
			throw new IllegalArgumentException("The scale must be a positive integer or zero");  
		}  
		BigDecimal b = new BigDecimal(v);  
		return b.setScale(scale, round_mode).toString();  
	}  
	/*
	 * 时间算法
	 */
	public  String calcuDate(String dateStr){
		SimpleDateFormat sdf=new SimpleDateFormat("yyyyMMdd");
		String newDate=null;
		try {
			Date date=sdf.parse(dateStr);
			Date date2=new Date(date.getTime()-24*60*60*1000);
			newDate=sdf.format(date2);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return newDate;
	}


	public static String math12(double obj,int len){
		
		String last=String.valueOf(obj);
		if(last==null||last.length()==0 || last.equals("0")){
			return "000000000.00";
		}else{
			int index=last.lastIndexOf(".");
			if(last.length()-(index+1)<2){
				last=last+"0";
			}
			for(int i=0;i<len;i++){
				last="0"+last;
				if(last.length()>=len){
					break;
				}
			}
		}
		return last;
	}
	
	public static void main(String[] arges) {
//		System.out.println(multiply((double)3,2395.21));
		int a=9;
		int b=9;
		System.out.println(a*b);
		
//		System.out.println((int)multiply(12.51,1.21));
	}
}
